Scala Tutorial

● Scala

✦tutorial intro

✦Overview

✦Features

✦Environment Setup

✦Build Tool (SBT)

● Scala Basics

✦Structure

✦hello world

✦variables

✦variable scope

✦Identifiers

✦Keywords

✦Comments

✦Code Blocks

✦Semicolon

✦Input and Output

✦var vs val

● Scala Datatypes

✦Byte

✦Short

✦Int

✦Long

✦Float

✦Double

✦Char

✦String

✦Boolean

✦Unit

✦Null

✦Nothing

✦Any

✦AnyRef

● Unit Type

✦Unit Type overview

✦Nothing

✦null unit

✦unit type best practice

● Strings

✦Strings overview

✦concatenation

✦String Interpolation

✦string Escape Characters

✦string methods

● Arrays

✦Arrays overview

✦iterate

✦multidimensional array

✦array methods

● Pattern Matching

✦Pattern Matching overview

✦case classes

✦matching in if condition

✦matching using type

● Tuples

✦Tuples overview

✦access

✦operations

✦pattern matching in tuple

● Option

✦Option and some

✦pattern matching with option

● Typecasting

✦Type Casting

✦all datatypes example

● Enumerations

✦Enumerations intro

✦Enum And Algebraic Data Types

✦Enumerations operations

● Scala Operators

✦Rules for Operators

✦Arithmetic Operators

✦Relational Operators

✦Logical Operators

✦Bitwise Operators

✦Assignment Operators

✦Operators Precedence

✦Symbolic Operators

✦Range Operator

● Scala Decision Making

✦IF ELSE

✦IF-ELSE-IF-ELSE Statement

✦Nested IF-ELSE Statement

✦if else as expression

● Scala Loops

✦Loop Statements

✦while Loop

✦do-while Loop

✦Nested Loops

✦for Loop

✦break Statement

✦yield Keyword

✦range - to

✦range - until

✦range - by

● Functions

✦Functions overview

✦Functions Call-by-Name

✦Functions with Named Arguments

✦Function with Variable Arguments

✦Function With Parameters

✦Function With Option Parameters

✦Function With Option Return Type

✦Function With Implicit Parameter

✦Default Parameter Values

✦Implicit Function

✦Typed Function

✦Polymorphic Function

✦Function With Generic Return Type

✦Variable Argument Function

✦Functions As Symbols

✦Higher Order Function

✦Higher Order Function - Call By Name Function

✦Higher Order Function - With Callback Parameter

✦Function Using The Val Keyword Instead Of Def

✦Function Composition Using AndThen

✦Function Composition Using Compose

✦Recursion Functions

✦Tail Recursive Function with annotation

✦Tail Recursive Function with tailcall package

✦Trampoline Tail Recursive Function

✦Anonymous Functions

✦Partial Functions

✦Nested Function

✦Currying Functions

● Scala OOPs Concepts

✦OOP Overview

✦Classes & Objects

✦Companion Objects

✦Values And Fields In Companion Object

✦Singleton Object

✦Case Class

✦Constructors

✦Type Aliasing

✦Implicit Class

✦Package Objects

✦Extractors

✦Access Modifiers

✦Method Overloading

✦This keyword

✦Inheritance

✦Method Overriding

✦Field Overriding

✦Final

✦Abstract Class

✦Typed Class

✦Covariance

✦Contra-Variance

● Scala Traits

✦Traits overview

✦Create And Extend Trait

✦Trait With Type Parameters

✦Extend Multiple Traits

✦Dependency Injection Using Traits

✦Traits & Companion Objects

✦Factory Pattern

✦Type Class For Ad-hoc Polymorphism

✦Trait Mixin And Linearization

✦The Magnet Pattern

● Scala Immutable Collection

✦Overview

✦Data Structures

✦List

✦ListSet

✦ListMap

✦Map

✦HashMap

✦TreeMap

✦Queue

✦Sequence

✦Set

✦HashSet

✦TreeSet

✦SortedSet

✦BitSet

✦Stack

✦Stream

✦Vector

● Scala Mutable Collection

✦Overview

✦Array

✦ArrayBuffer

✦ArrayStack

✦ListBuffer

✦Map

✦HashMap

✦ListMap

✦LinkedHashMap

✦Queue

✦PriorityQueue

✦Set

✦HashSet

✦SortedSet

✦TreeSet

✦LinkedHashSet

✦BitSet

● Scala Exceptions

✦Exceptions

✦Exception Handling

✦Try Catch Block

✦Finally Block

✦Throw keyword

✦Throws keyword

✦Custom Exception

● Scala Additional topics

✦Tuples

✦Iterators

✦Options

✦Array with Range

✦DropWhile Method

✦Filter Method

✦FoldRight Method

✦Reduce Method

✦Zip Method

✦File Handling

✦Multihreading

✦Thread

✦Thread Methods

✦Futures

✦Annotations

● Scala Array Method

✦def apply[T : ClassTag](xs: T*): Array[T]

✦def apply(x: Boolean, xs: Boolean*): Array[Boolean]

✦def apply(x: Byte, xs: Byte*): Array[Byte]

✦def apply(x: Short, xs: Short*): Array[Short]

✦def apply(x: Char, xs: Char*): Array[Char]

✦def apply(x: Int, xs: Int*): Array[Int]

✦def apply(x: Long, xs: Long*): Array[Long]

✦def apply(x: Float, xs: Float*): Array[Float]

✦def apply(x: Double, xs: Double*): Array[Double]

✦def apply(x: Unit, xs: Unit*): Array[Unit]

✦def concat[T : ClassTag](xss: Array[T]*): Array[T]

✦def copy(src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int): Unit

✦def copyAs[A](original: Array[_], newLength: Int)(implicit ct: ClassTag[A]): Array[A]

✦default values (if necessary) so the copy has the specified length.

✦def copyOf[A](original: Array[A], newLength: Int): Array[A]

✦def empty[T : ClassTag]: Array[T]

✦def equals(xs: Array[AnyRef], ys: Array[AnyRef]): Boolean

✦def fill[T : ClassTag](n: Int)(elem: => T): Array[T]

✦def fill[T : ClassTag](n1: Int, n2: Int)(elem: => T): Array[Array[T]]

✦def fill[T : ClassTag](n1: Int, n2: Int, n3: Int)(elem: => T): Array[Array[Array[T]]]

✦def fill[T : ClassTag](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => T): Array[Array[Array[Array[T]]]]

✦def fill[T : ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => T): Array[Array[Array[Array[Array[T]]]]]

✦def from[A : ClassTag](it: IterableOnce[A]): Array[A]

✦def iterate[T : ClassTag](start: T, len: Int)(f: T => T): Array[T]

✦def newBuilder[T](implicit t: ClassTag[T]): ArrayBuilder[T]

✦def ofDim[T : ClassTag](n1: Int): Array[T]

✦def ofDim[T : ClassTag](n1: Int, n2: Int): Array[Array[T]]

✦def ofDim[T : ClassTag](n1: Int, n2: Int, n3: Int): Array[Array[Array[T]]]

✦def ofDim[T : ClassTag](n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[T]]]]

✦def ofDim[T : ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[T]]]]]

✦def range(start: Int, end: Int): Array[Int]

✦def range(start: Int, end: Int, step: Int): Array[Int]

✦def tabulate[T : ClassTag](n: Int)(f: Int => T): Array[T]

✦def tabulate[T : ClassTag](n1: Int, n2: Int)(f: (Int, Int) => T): Array[Array[T]]

✦def tabulate[T : ClassTag](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => T): Array[Array[Array[T]]]

✦def tabulate[T : ClassTag](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => T): Array[Array[Array[Array[T]]]]

✦def tabulate[T : ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => T): Array[Array[Array[Array[Array[T]]]]]

✦def unapplySeq[T](x: Array[T]): UnapplySeqWrapper[T]

● Scala Option method

✦final def collect[B](pf: PartialFunction[A, B]): Option[B]

✦final def contains[A1 >: A](elem: A1): Boolean

✦final def exists(p: A => Boolean): Boolean

✦final def filter(p: A => Boolean): Option[A]

✦final def filterNot(p: A => Boolean): Option[A]

✦final def flatMap[B](f: A => Option[B]): Option[B]

✦def flatten[B](implicit ev: A <:< Option[B]): Option[B]

✦final def fold[B](ifEmpty: => B)(f: A => B): B

✦final def forall(p: A => Boolean): Boolean

✦final def foreach[U](f: A => U): Unit

✦final def getOrElse[B >: A](default: => B): B

✦final def isDefined: Boolean

✦final def isEmpty: Boolean

✦def iterableFactory: IterableFactory[Iterable]

✦def iterator: Iterator[A]

✦final override def knownSize: Int

✦def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, this.type]

✦final def map[B](f: A => B): Option[B]

✦final def nonEmpty: Boolean

✦final def orElse[B >: A](alternative: => Option[B]): Option[B]

✦final def orNull[A1 >: A](implicit ev: Null <:< A1): A1

✦final def toLeft[X](right: => X): Either[A, X]

✦def toList: List[A]

✦final def toRight[X](left: => X): Either[X, A]

✦final def unzip[A1, A2](implicit asPair: A <:< (A1, A2)): (Option[A1], Option[A2])

✦final def unzip3[A1, A2, A3](implicit asTriple: A <:< (A1, A2, A3)): (Option[A1], Option[A2], Option[A3])

✦final def withFilter(p: A => Boolean): WithFilter

✦final def zip[A1 >: A, B](that: Option[B]): Option[(A1, B)]

● Scala String method

✦def *(n: Int): String

✦def ++[B >: Char](suffix: Iterable[B]): IndexedSeq[B]

✦def ++(suffix: IterableOnce[Char]): String

✦def ++(xs: String): String

✦def ++:[B >: Char](prefix: IterableOnce[B]): IndexedSeq[B]

✦def ++:(prefix: String): String

✦def +:[B >: Char](elem: B): IndexedSeq[B]

✦def +:(c: Char): String

✦def :+[B >: Char](elem: B): IndexedSeq[B]

✦def :+(c: Char): String

✦def :++[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]

✦def :++(suffix: String): String

✦def <(that: String): Boolean

✦def <=(that: String): Boolean

✦def >(that: String): Boolean

✦def >=(that: String): Boolean

✦final def addString(b: StringBuilder): b.type

✦final def addString(b: StringBuilder, sep: String): b.type

✦final def addString(b: StringBuilder, start: String, sep: String, end: String): b.type

✦def appended[B >: Char](elem: B): IndexedSeq[B]

✦def appended(c: Char): String

✦def appendedAll[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]

✦def appendedAll(suffix: String): String

✦def apply(i: Int): Char

✦def capitalize: String

✦def charStepper: IntStepper & EfficientSplit

✦def codePointStepper: IntStepper & EfficientSplit

✦def collect(pf: PartialFunction[Char, Char]): String

✦def collect[B](pf: PartialFunction[Char, B]): IndexedSeq[B]

✦def combinations(n: Int): Iterator[String]

✦def compare(that: String): Int

✦def concat[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]

✦def concat(suffix: IterableOnce[Char]): String

✦def concat(suffix: String): String

✦def contains(elem: Char): Boolean

✦def copyToArray(xs: Array[Char]): Int

✦def copyToArray(xs: Array[Char], start: Int): Int

✦def copyToArray(xs: Array[Char], start: Int, len: Int): Int

✦def count(p: Char => Boolean): Int

✦def diff[B >: Char](that: Seq[B]): String

✦def distinct: String

✦def distinctBy[B](f: Char => B): String

✦def drop(n: Int): String

✦def dropRight(n: Int): String

✦def dropWhile(p: Char => Boolean): String

✦def exists(p: Char => Boolean): Boolean

✦def filter(pred: Char => Boolean): String

✦def filterNot(pred: Char => Boolean): String

✦def find(p: Char => Boolean): Option[Char]

✦def flatMap[B](f: Char => IterableOnce[B]): IndexedSeq[B]

✦def flatMap(f: Char => String): String

✦def fold[A1 >: Char](z: A1)(op: (A1, A1) => A1): A1

✦def foldLeft[B](z: B)(op: (B, Char) => B): B

✦def foldRight[B](z: B)(op: (Char, B) => B): B

✦def forall(p: Char => Boolean): Boolean

✦def foreach[U](f: Char => U): Unit

✦def format(args: Any*): String

✦def formatLocal(l: Locale, args: Any*): String

✦def groupBy[K](f: Char => K): Map[K, String]

✦def grouped(size: Int): Iterator[String]

✦def head: Char

✦def headOption: Option[Char]

✦def indexWhere(p: Char => Boolean, from: Int): Int

✦def indices: Range

✦def init: String

✦def inits: Iterator[String]

✦def intersect[B >: Char](that: Seq[B]): String

✦def iterator: Iterator[Char]

✦def knownSize: Int

✦def last: Char

✦def lastIndexWhere(p: Char => Boolean, end: Int): Int

✦def lastOption: Option[Char]

✦def lazyZip[B](that: Iterable[B]): LazyZip2[Char, B, String]

✦def lengthCompare(len: Int): Int

✦def lengthIs: Int

✦def linesIterator: Iterator[String]

✦def linesWithSeparators: Iterator[String]

✦def map[B](f: Char => B): IndexedSeq[B]

✦def map(f: Char => Char): String

✦final def mkString(start: String, sep: String, end: String): String

✦final def mkString(sep: String): String

✦final def mkString: String

✦def nonEmpty: Boolean

✦def padTo[B >: Char](len: Int, elem: B): IndexedSeq[B]

✦def padTo(len: Int, elem: Char): String

✦def partition(p: Char => Boolean): (String, String)

✦def partitionMap(f: Char => Either[Char, Char]): (String, String)

✦def patch[B >: Char](from: Int, other: IterableOnce[B], replaced: Int): IndexedSeq[B]

✦def patch(from: Int, other: IterableOnce[Char], replaced: Int): String

✦def patch(from: Int, other: String, replaced: Int): String

✦def permutations: Iterator[String]

✦def prepended[B >: Char](elem: B): IndexedSeq[B]

✦def prepended(c: Char): String

✦def prependedAll[B >: Char](prefix: IterableOnce[B]): IndexedSeq[B]

✦def prependedAll(prefix: String): String

✦def r: Regex

✦def reverse: String

✦def reverseIterator: Iterator[Char]

✦def size: Int

✦def sizeCompare(otherSize: Int): Int

✦def sizeIs: Int

✦def slice(from: Int, until: Int): String

✦def sliding(size: Int, step: Int): Iterator[String]

✦def sortBy[B](f: Char => B)(implicit ord: Ordering[B]): String

✦def sortWith(lt: (Char, Char) => Boolean): String

✦def sorted[B >: Char](implicit ord: Ordering[B]): String

✦def span(p: Char => Boolean): (String, String)

✦def split(separator: Char): Array[String]

✦def split(separators: Array[Char]): Array[String]

✦def splitAt(n: Int): (String, String)

✦def stepper: IntStepper & EfficientSplit

✦def stripLineEnd: String

✦def stripMargin(marginChar: Char): String

✦def stripMargin: String

✦def stripPrefix(prefix: String): String

✦def stripSuffix(suffix: String): String

✦def tail: String

✦def tails: Iterator[String]

✦def take(n: Int): String

✦def takeRight(n: Int): String

✦def takeWhile(p: Char => Boolean): String

✦def toArray[B >: Char](implicit tag: ClassTag[B]): Array[B]

✦def toBoolean: Boolean

✦def toBooleanOption: Option[Boolean]

✦def toByte: Byte

✦def toByteOption: Option[Byte]

✦def toDouble: Double

✦def toDoubleOption: Option[Double]

✦def toFloat: Float

✦def toFloatOption: Option[Float]

✦def toInt: Int

✦def toIntOption: Option[Int]

✦def toLong: Long

✦def toLongOption: Option[Long]

✦def toShort: Short

✦def toShortOption: Option[Short]

✦def updated(index: Int, elem: Char): String

✦def view: StringView

✦def withFilter(p: Char => Boolean): WithFilter

✦def lines: Iterator[String]

✦def r(groupNames: String*): Regex

✦def replaceAllLiterally(literal: String, replacement: String): String

● Scala Math method

✦defmax(x: Double, y: Double): Double

✦defmax(x: Float, y: Float): Float

✦defmax(x: Long, y: Long): Long

✦defmax(x: Int, y: Int): Int

✦defmin(x: Double, y: Double): Double

✦defmin(x: Float, y: Float): Float

✦defmin(x: Long, y: Long): Long

✦defmin(x: Int, y: Int): Int

✦defIEEEremainder(x: Double, y: Double): Double

✦defceil(x: Double): Double

✦deffloor(x: Double): Double

✦defrint(x: Double): Double

✦defround(x: Double): Long

✦defround(x: Float): Int

✦defround(x: Long): Long

✦defexp(x: Double): Double

✦defexpm1(x: Double): Double

✦deflog(x: Double): Double

✦deflog10(x: Double): Double

✦deflog1p(x: Double): Double

✦defpow(x: Double, y: Double): Double

✦defacos(x: Double): Double

✦defasin(x: Double): Double

✦defatan(x: Double): Double

✦defcos(x: Double): Double

✦defsin(x: Double): Double

✦deftan(x: Double): Double

✦deftoDegrees(x: Double): Double

✦deftoRadians(x: Double): Double

✦defcosh(x: Double): Double

✦defsinh(x: Double): Double

✦deftanh(x: Double): Double

✦defabs(x: Double): Double

✦defabs(x: Float): Float

✦defabs(x: Long): Long

✦defabs(x: Int): Int

✦defsignum(x: Double): Double

✦defsignum(x: Float): Float

✦defsignum(x: Long): Long

✦defsignum(x: Int): Int

✦defcbrt(x: Double): Double

✦defsqrt(x: Double): Double

✦defatan2(y: Double, x: Double): Double

✦defhypot(x: Double, y: Double): Double

✦defulp(x: Float): Float

✦defulp(x: Double): Double

✦defrandom(): Double

Scala Decision Making → if else as expression

Tutorials

Popular Languages

All Interpreters/IDE

vb.net(visualbasic)

Quick Links

Advertise with us About us Contact us Disclaimer Privacy Policy Terms & Conditions

© 2025 Tutorialix.com. All rights reserved.